#!/usr/bin/env node
// OSRM query runner - executes routing queries against OSRM server and collects performance metrics

import fs from 'fs';
import http from 'http';
import process from 'process';
import cla from 'command-line-args';
import clu from 'command-line-usage';
import ansi from 'ansi-escape-sequences';
import turf from 'turf';
import jp from 'jsonpath';
import { stringify as csv_stringify } from 'csv-stringify/lib/sync';

// Execute HTTP query against OSRM server and measure response times
const run_query = (query_options, filters, callback) => {
  let tic = () => 0.;
  http.request(query_options, function (res) {
    let body = '', ttfb = tic();

    res.setEncoding('utf8');
    res.on('data', function (chunk) {
      body += chunk;
    });
    res.on('end', function () {
      const elapsed = tic();
      const json = JSON.parse(body);
      Promise.all(filters.map(filter => jp.query(json, filter)))
        .then(values => callback(query_options.path, res.statusCode, ttfb, elapsed, values));
    });
  }).on('socket', function (/*res*/) {
    tic = ((toc) => { return () => { const t = process.hrtime(toc); return t[0] * 1000 + t[1] / 1000000; }; })(process.hrtime());
  }).on('error', function (res) {
    callback(query_options.path, res.code);
  }).end();
};

// Generate random coordinate points within a polygon boundary for route testing
function generate_points(polygon, number, coordinates_number, max_distance) {
  let query_points = [];
  while (query_points.length < number) {
    let points = [];

    while(points.length < coordinates_number) {
      let chunk = turf
        .random('points', coordinates_number, { bbox: turf.bbox(polygon)})
        .features
        .map(x => x.geometry.coordinates)
        .filter(pt => turf.inside(pt, polygon));

      if (max_distance > 0)
      {
        chunk.forEach(pt => {
          if (points.length == 0)
          {
            points.push(pt);
          }
          else
          {
            let distance = turf.distance(pt, points[points.length-1], 'meters');
            if (distance < max_distance)
            {
              points.push(pt);
            }
          }
        });
      }
      else
      {
        points = points.concat(chunk);
      }
    }

    query_points.push(points);
  }

  return query_points;
}

// Convert coordinate points into OSRM API query URLs
function generate_queries(options, query_points) {
  let queries = query_points.map(points => {
    return options.path.replace(/{}/g, x =>  points.pop().join(','));
  });
  return queries;
}

// Parse server hostname:port from command line arguments
function ServerDetails(x) {
  if (!(this instanceof ServerDetails)) return new ServerDetails(x);
  const v = x.split(':');
  this.hostname = (v[0].length > 0) ? v[0] : '';
  this.port = (v.length > 1) ? Number(v[1]) : 80;
}
// Parse geographic bounding box coordinates from command line
function BoundingBox(x) {
  if (!(this instanceof BoundingBox)) return new BoundingBox(x);
  const v = x.match(/[+-]?\d+(?:\.\d*)?|\.\d+/g);
  this.poly = turf.bboxPolygon(v.slice(0,4).map(x => Number(x)));
}
const optionsList = [
  {name: 'help', alias: 'h', type: Boolean, description: 'Display this usage guide.', defaultValue: false},
  {name: 'server', alias: 's', type: ServerDetails, defaultValue: ServerDetails('localhost:5000'), description: 'OSRM routing server', typeLabel: '{underline hostname[:port]}'},
  {name: 'path', alias: 'p', type: String, defaultValue: '/route/v1/driving/{};{}', description: 'OSRM query path with \\{\\} coordinate placeholders, default /route/v2/driving/\\{\\};\\{\\}', typeLabel: '{underline path}'},
  {name: 'filter', alias: 'f', type: String, defaultValue: ['$.routes[0].weight'], multiple: true, description: 'JSONPath filters, default "$.routes[0].weight"', typeLabel: '{underline filter}'},
  {name: 'bounding-box', alias: 'b', type: BoundingBox, defaultValue: BoundingBox('5.86442,47.2654,15.0508,55.1478'), multiple: true, description: 'queries bounding box, default "5.86442,47.2654,15.0508,55.1478"', typeLabel: '{underline west,south,east,north}'},
  {name: 'max-sockets', alias: 'm', type: Number, defaultValue: 1, description: 'how many concurrent sockets the agent can have open per origin, default 1', typeLabel: '{underline number}'},
  {name: 'number', alias: 'n', type: Number, defaultValue: 10, description: 'number of query points, default 10', typeLabel: '{underline number}'},
  {name: 'max-distance', alias: 'd', type: Number, defaultValue: -1, description: 'maximal distance between coordinates', typeLabel: '{underline number}'},
  {name: 'queries-files', alias: 'q', type: String, description: 'CSV file with queries in the first row', typeLabel: '{underline file}'},
];
const options = cla(optionsList);
if (options.help) {
  const banner =`\
  ____  _______  __  ______  __  ___  ___  _________
 / __ \\/ __/ _ \\/  |/  / _ \\/ / / / |/ / |/ / __/ _ \\
/ /_/ /\\ \\/ , _/ /|_/ / , _/ /_/ /    /    / _// , _/
\\____/___/_/|_/_/  /_/_/|_|\\____/_/|_/_/|_/___/_/|_|`;
  const usage = clu([
    { content: ansi.format(banner, 'green'), raw: true },
    { header: 'Run OSRM queries and collect results'/*, content: 'Generates something [italic]{very} important.'*/ },
    { header: 'Options', optionList: optionsList }
  ]);
  console.log(usage);
  process.exit(0);
}

// Load queries from file or generate random coordinate-based queries
let queries = [];
if (options.hasOwnProperty('queries-files')) {
  queries = fs.readFileSync(options['queries-files'])
    .toString()
    .split('\n')
    .map(r => { const match = /^"([^\"]+)"/.exec(r); return match ? match[1] : null; })
    .filter(q => q);
} else {
  const polygon = options['bounding-box'].map(x => x.poly).reduce((x,y) => turf.union(x, y));
  const coordinates_number = (options.path.match(/{}/g) || []).length;
  const query_points = generate_points(polygon, options.number, coordinates_number, options['max-distance']);
  queries = generate_queries(options, query_points);
}
queries = queries.map(q => { return {hostname: options.server.hostname, port: options.server.port, path: q}; });

// Execute all queries and output results in CSV format
http.globalAgent.maxSockets = options['max-sockets'];
queries.map(query => {
  run_query(query, options.filter, (query, code, ttfb, total, results) => {
    let data = results ? JSON.stringify(results[0]) : '';
    let record = [[query, code, ttfb, total, data]];
    process.stdout.write(csv_stringify(record));
  });
});